# 10.dict 字典数据类型

# 字典类型(dict)

字典是Python唯一的一个映射类型，字典的意义：就是为了可以快速的查找或定位数据

格式：{ } 使用花(大)括号括起来的键值对(key:value) 保存数据

在字典中，key是唯一的，在保存的时候，会根据key来计算出一个内存地址，然后将key_value保存在这个地址中，这种算法被称为：hash算法(哈希算法)

在字典中，字典存储的 key:value 中的 key必须要可hash / 哈希，就是不可变的，而value不限制

可哈希(不可变)的数据类型：整形类型(int)，布尔类型(bool)，字符串类型(str)，元组类型(tuple)

不可哈希(可变)的数据类型：列表类型(list)，字典类型(dict)，集合类型(set)

so = {1:"周杰伦","2":"林俊杰",(3,):"周芷若",False:"周润发"}
print(so)

执行结果：
{1: '周杰伦', '2': '林俊杰', (3,): '周芷若', False: '周润发'}

运用了，整形，字符串，布尔，元组来作为字典的key值

# 字典的的增删改查

# 增加

# 增加(存在就替代)

向字典中增加数据

如果字典中，有相同的key字段，会直接修改为最新赋值的内容

格式：字典变量[key值] = "value值"

so = {}
so["昆凌"] = "周杰伦的老婆"
print(so)

执行结果：
{'昆凌': '周杰伦的老婆'}

# 增加(存在不保存) - setdefault()

向字典中增加数据

如果字典中，有相同的key字段，默认不保存

格式：字典变量.setdefault(key值, value值)

so = {}
so["昆凌"] = "周杰伦的老婆"
so.setdefault("杨紫","张一山的女朋友")
so.setdefault("杨紫","是张一山的女朋友？？？")
print(so)

执行结果：
{'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友'}

# 获取 setdefault()的返回值

在添加的时候，无论是否添加成功， setdefault()都会返回一个添加的key对应的value值

so = {"杨紫":"不想当张一山的女朋友"}
so["昆凌"] = "周杰伦的老婆"
soo = so.setdefault("杨紫","张一山的女朋友")
print("增加后的返回值：",soo)
print(so)

执行结果：
增加后的返回值： 不想当张一山的女朋友
{'杨紫': '不想当张一山的女朋友', '昆凌': '周杰伦的老婆'}

以上实例，无论增加是否成功都会返回key对应的值，简单来说，就是他执行是分成二部分，先增加，在查询

# 删除

# 按key值删除 - pop()

通过指定的key值删除指定的内容，如果不填key值，程序会报错

格式：字典变量.pop(key值)

so = {'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友'}
so.pop("昆凌")
print(so)

执行结果：
{'杨紫': '张一山的女朋友'}

# 获取删除的value值 - pop()

格式：变量 = 字典变量.pop(key值)

so = {'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友'}
soo = so.pop("昆凌")
print("删除的值：",soo)
print(so)

执行结果：
删除的值： 周杰伦的老婆
{'杨紫': '张一山的女朋友'}

# 随机删除 - popitem()

随机删除字典的一个数据，删除那个不固定，看系统心情

格式：字典变量.popitem()

so = {'昆凌': '我是周杰伦的老婆', '杨紫': '我是张一山的女朋友',"张一山":"想让杨紫当我老婆","周杰伦":"我要看好我老婆"}
so.popitem()
print(so)

执行结果：
{'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友', '张一山': '想让杨紫当我老婆'}

# 获取删除的值 - popitem()

需要注意：获取后的返回值是元组类型

格式：变量 = 字典变量.popitem()

so = {'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友',"张一山":"想让杨紫当我老婆","周杰伦":"我要看好我老婆"}
soo = so.popitem()
print("删除的值：",soo)
print(so)

执行结果：
删除的值： ('周杰伦', '我要看好我老婆')
{'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友', '张一山': '想让杨紫当我老婆'}

# 清空字典 - clear()

清空字典内的所有数据

格式：字典变量.clear()

so = {'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友',"张一山":"想让杨紫当我老婆","周杰伦":"我要看好我老婆"}
so.clear()
print(so)

执行结果：
{}

# 全局删除-del

能删单一的值，也可以删除字典本身

格式：del 字典变量[key值]

so = {'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友',"张一山":"想让杨紫当我老婆","周杰伦":"我要看好我老婆"}
del so["周杰伦"]
print(so)

执行结果：
{'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友', '张一山': '想让杨紫当我老婆'}

以上实例，指定key值删除

so = {'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友',"张一山":"想让杨紫当我老婆","周杰伦":"我要看好我老婆"}
del so
print(so)

执行结果：
NameError: name 'so' is not defined
意思：没有定义名称“so”

以上实例，如果想要删除字典本身，可以使用这个方法

# 修改

# 常用修改

修改字典中的数据

格式：字典变量[key值] = "value值"

so = {'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友',"张一山":"想让杨紫当我老婆","周杰伦":"我要看好我老婆"}
so["张一山"] = "我不想让杨紫当我老婆了"
print(so
      
执行结果：
{'昆凌': '周杰伦的老婆', '杨紫': '张一山的女朋友', '张一山': '我不想让杨紫当我老婆了', '周杰伦': '我要看好我老婆'}

以上实例，注意，如果修改的key值不存在，默认会创建一个新的内容

# 实例：模拟银行扣费

使用元组类型，来模拟银行扣费

so = {"name":"江凡","bank":"建设银行","money":10000}
while 1:
    print("=" * 30)
    print("姓名：",so["name"])
    print("所属银行：",so["bank"])
    print("当前金额：",so["money"])
    print("=" * 30)
    mone = input("请输入要取出的额度，最低：100 退出请按 Q ：")
    if mone.upper() == "Q":
        print("退出，欢迎下次光临")
        break
    elif mone.isdigit() == False:
        print("请输入金额数字或输入Q退出")
        continue
    elif int(mone) <= so["money"]:
        so["money"] = so["money"] - int(mone)
    else:
        print("输入的金额，大于存储的金额，请重新输入")

# 将别字典更新到字典中-update()

将另一个字典的内容更新到当前字典中

格式：字典变量.update(别一个字典变量)

so = {'昆凌': '周杰伦的老婆',"周杰伦":"我要看好我老婆"}
so1 = {'杨紫': '张一山的女朋友',"张一山":"想让杨紫当我老婆"}
so.update(so1)
print(so)

执行结果：
{'昆凌': '周杰伦的老婆', '周杰伦': '我要看好我老婆', '杨紫': '张一山的女朋友', '张一山': '想让杨紫当我老婆'}

以上实例，将so1中的内容全部更新的so中

# 查询

# 查询(如果不存在报错)

按key值查询对应的value值，如果key不存在，程序报错

格式：字典变量[key值]

so = {1:"董事部",2:"财务部",3:"业务部",4:"人力行政部",5:"技术部"}
print(so[2])

执行结果：
财务部

# 查询(如果不存在返回值) －get()

也是按key值来查询对应的value值，不过如果key不存在，默认会输出"None"，也可以自己定义

二种格式：

变量.get(key值)

so = {1:"董事部",2:"财务部",3:"业务部",4:"人力行政部",5:"技术部"}
print(so.get(3))

执行结果：
业务部

变量 = 变量.get(key值,返回值)

so = {1:"董事部",2:"财务部",3:"业务部",4:"人力行政部",5:"技术部"}
soo = so.get(10)
print(soo)

执行结果：
None

以上的实例，输入的key不存在，默认返回None

so = {1:"董事部",2:"财务部",3:"业务部",4:"人力行政部",5:"技术部"}
soo = so.get(10,"key值不存在")
print(soo)

执行结果：
key值不存在

以上的实例，输入的key不存在，但我们定义了返回值为 key值不存在 , 就会返回并输出

# 多字典键 - fromkey()

fromkeys() 函数用于创建一个新字典，以key中元素做字典的键，value为字典所有键对应的初始值。

格式：变量 = dict.fromkeys(key,value)

so = dict.fromkeys(["明星","歌手"],["周杰伦","周树人","周星星"])
print(so)

执行结果：
{'明星': ['周杰伦', '周树人', '周星星'], '歌手': ['周杰伦', '周树人', '周星星']}

列表中的每⼀项都会作为key, 后面列表中的内容作为value. 生成dict

so = dict.fromkeys(["明星","歌手"],["周杰伦","周树人","周星星"])
print(so)
so["明星"].append("江凡")
print(so)

执行结果：
{'明星': ['周杰伦', '周树人', '周星星'], '歌手': ['周杰伦', '周树人', '周星星']}
{'明星': ['周杰伦', '周树人', '周星星', '江凡'], '歌手': ['周杰伦', '周树人', '周星星', '江凡']}

增加值的时候只增加了明星这个key值，那为什么另一个key值也会跟着增加，因为以上两个Key值是同用一个列表，所以改了一个，另一个也会跟着改

还有其它用法，如需自行百度

#

# 字典的for循环操作

在for循环中使用字典迭代，出来的数据是字典的key值

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
for i in so:
    print(so[i])
    
执行结果：
董事部
财务部
业务部
人力行政部
技术部

以上实例，因知道了for循环出来的是字典的key值，那直接拿key值来获取value值

# 实例：for循环删除

要求：删除所有带技术部的值，{1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部",6: "技术部"}

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部",6: "技术部"}
wo = []
for i in so:
    if so[i] == "技术部":
        wo.append(i)
for i in wo:
    del so[i]
print(so)

执行结果：
{1: '董事部', 2: '财务部', 3: '业务部', 4: '人力行政部'}

# 字典常用操作

# 获取字典中所有的key值 - keys()

可以查询字典中的所有key值

注意：keys()的返回结果很像列表或元组，但不是列表跟元组

也可以通过for循环进行迭代循环查询

格式：字典变量.keys()

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
print(so.keys())

执行结果：
dict_keys([1, 2, 3, 4, 5])

以上实例，返回所有key值，返回值很像列表或元组，但是不是列表或元组类型

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
for i in so.keys():
    print(i)

执行结果：
1
2
3
4
5

以上实例，可以通过for循环来迭代循环查询所有的key值

# 获取字典中所有的value值 - values()

可以查询获取字典中的所有value值

注意：values()的返回结果很像列表或元组，但不是列表跟元组

也可以通过for循环进行迭代循环查询

格式：字典变量.values()

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
print(so.values())

执行结果：
dict_values(['董事部', '财务部', '业务部', '人力行政部', '技术部'])

以上实例，返回所有value值，返回值很像列表或元组，但是不是列表或元组类型

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
for i in so.values():
    print(i)
    
执行结果：
董事部
财务部
业务部
人力行政部
技术部

以上实例，可以通过for循环来迭代循环查询所有的value值

# 获取字典中的key跟value值 - itmes()

可以查询获取字典中的所有key值跟value值，返回的内存key跟value是由元组组成

注意：itmes()的返回结果很像列表或元组，但不是列表跟元组

也可以通过for循环进行迭代循环查询

格式：字典变量.itmes()

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
print(so.items())

执行结果：
dict_items([(1, '董事部'), (2, '财务部'), (3, '业务部'), (4, '人力行政部'), (5, '技术部')])

以上实例，返回所有key值跟value值，返回值很像列表或元组，但是不是列表或元组类型

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
for i in so.items():
    print(i)
    
执行结果：
(1, '董事部')
(2, '财务部')
(3, '业务部')
(4, '人力行政部')
(5, '技术部')

以上实例，可以通过for循环来迭代循环查询所有的key值跟value值

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
for i in so.items():
    print(i[0])
    
执行结果：
1
2
3
4
5

以上实例，可以通过for循环来迭代循环查询所有的key值

so = {1: "董事部", 2: "财务部", 3: "业务部", 4: "人力行政部", 5: "技术部"}
for i in so.items():
    print(i[1])
    
执行结果：
董事部
财务部
业务部
人力行政部
技术部

以上实例，可以通过for循环来迭代循环查询所有的value值

# 字典的嵌套

so = {'name': '江凡', 'age': '22', 'wife': {'name': '小燕子', 'age': '21'}, 'childern': [{'name': '小笨蛋', 'age': 3, 'sex': '男'}, {'name': '小宝贝', 'age': 1, 'sex': '女'}], 'parent': {'father': {'name': '江太爷', 'age': 61}, 'mother': {'name': '陈太婆', 'age': 58}}}

========
===或===
========

so = {
    "name":"江凡",
    "age":"22",
    "wife":{
        "name":"小燕子",
        "age":"21"
    },
    "childern":[
        {
            "name":"小笨蛋",
             "age":3,
            "sex":"男"
         },
        {
            "name":"小宝贝",
            "age":1,
            "sex":"女"
         }
    ],
    "parent":{
        "father":{
            "name":"江太爷",
            "age":61,
        },
        "mother":{
            "name":"陈太婆",
            "age":58
        }
    }
}

# 查询江凡他女儿的姓名

print(so["childern"][1]["name"])
或
print(so.get("childern")[1].get("name"))

执行结果：
小宝贝

# 查询江凡他父亲的姓名

print(so["parent"]["father"]["name"])
或
print(so.get("parent").get("father").get("name"))

执行结果：
江太爷

# 查询江凡他老婆的姓名

print(so["wife"]["name"])
或
print(so.get("wife").get("name"))

执行结果：
小燕子

# 练习

题目

so = {'name':['alex',2,3,5],'job':'teacher','oldboy':{'alex':['python1','python2',100]}}

在name对应的列表追加一个元素’wusir’

so = {'name':['alex',2,3,5],'job':'teacher','oldboy':{'alex':['python1','python2',100]}}
so["name"].append("wusir")
print(so)

执行结果：
{'name': ['alex', 2, 3, 5, 'wusir'], 'job': 'teacher', 'oldboy': {'alex': ['python1', 'python2', 100]}}

在name对应的列表中的alex首字母大写

so = {'name':['alex',2,3,5],'job':'teacher','oldboy':{'alex':['python1','python2',100]}}
so["name"][0] = so["name"][0].capitalize()
print(so)

执行结果：
{'name': ['Alex', 2, 3, 5], 'job': 'teacher', 'oldboy': {'alex': ['python1', 'python2', 100]}}

oldboy对应的字典加一个键值对’少年’,’江凡’

so = {'name':['alex',2,3,5],'job':'teacher','oldboy':{'alex':['python1','python2',100]}}
so["oldboy"]["少年"] = "江凡"
print(so)

执行结果：
{'name': ['alex', 2, 3, 5], 'job': 'teacher', 'oldboy': {'alex': ['python1', 'python2', 100], '少年': '江凡'}}

将oldboy对应的字典中的alex对应的列表中的python2删除

so = {'name':['alex',2,3,5],'job':'teacher','oldboy':{'alex':['python1','python2',100]}}
so["oldboy"]["alex"].pop(1)
print(so)

执行结果：
{'name': ['alex', 2, 3, 5], 'job': 'teacher', 'oldboy': {'alex': ['python1', 100]}}

← 9.range函数 11.解构解包 →